home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / MysticView / source / MysticView.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-28  |  28.3 KB  |  1,239 lines
  1. /*********************************************************************
  2. ----------------------------------------------------------------------
  3.  
  4.     $VER: MysticView.c 0.68
  5.     by Captain Bifat
  6.     © 1996 TEK neoscientists
  7.  
  8.     simple Workbench DataType Picture Viewer 
  9.  
  10.     using render.library
  11.  
  12.     - appwindow reference: AmigaMail AppWindow.c
  13.     - picture datatype reference: Cloanto ViewDT.c
  14.  
  15. ------------------------------------------------------ tabsize = 4 ---
  16. *********************************************************************/
  17.  
  18. #include <stdio.h>
  19. #include <string.h>
  20.  
  21. #include <exec/memory.h>
  22. #include <intuition/intuition.h>
  23. #include <workbench/startup.h>
  24. #include <workbench/workbench.h>
  25. #include <render/render.h>
  26. #include <render/renderhooks.h>
  27. #include <libraries/gadtools.h>
  28. #include <utility/hooks.h>
  29.  
  30. #include <proto/exec.h>
  31. #include <proto/intuition.h>
  32. #include <proto/graphics.h>
  33. #include <proto/wb.h>
  34. #include <proto/dos.h>
  35. #include <proto/render.h>
  36. #include <proto/gadtools.h>
  37. #include <proto/asl.h>
  38.  
  39. #include "global.h"
  40.  
  41. #include "loaddtpicture.h"
  42. #include "guigfx.h"
  43. #include "Logo.h"
  44. #include "wbview.h"
  45.  
  46. /*------------------------------------------------------------------*/
  47.  
  48. #define    ID_APPWIN        0x123
  49. #define UDATA_APPWIN    0x777
  50.  
  51. #define    POOLPUDSIZE        10000
  52.  
  53. #define    RGBWEIGHT        0x080808
  54.  
  55.  
  56. #define MIN(a,b)        ((a) < (b) ? (a) : (b))
  57. #define MAX(a,b)        ((a) > (b) ? (a) : (b))
  58.  
  59.  
  60. #define    INFOTEXT_LOADED            "%s (%s)"
  61. #define    INFOTEXT_LOAD_ERROR        "(%s - Error)"
  62. #define    INFOTEXT_NO_DATATYPE    "(%s - Unknown)"
  63.  
  64. /*------------------------------------------------------------------*/
  65.  
  66. enum MITEMS {    MITEM_NOHIGHLIGHT=1,
  67.                 MITEM_OPEN,MITEM_ABOUT,MITEM_QUIT,
  68.                 MITEM_GREEDY,MITEM_ECONOMICAL,MITEM_SPARINGLY,MITEM_PASSIVE,
  69.                 MITEM_HAM_FAST,MITEM_HAM_BEST,MITEM_HAM_MEDIUM
  70.             };
  71.  
  72. /*
  73.  * Note: MITEM_NOHIGHLIGHT is a special constant that defines a
  74.  * menu entry's highlighting type to be set to HIGHNONE later.
  75.  */
  76.  
  77. struct NewMenu mainmenu[] =
  78. {
  79.     {NM_TITLE,    "Project",                0, 0, 0, 0},
  80.     {NM_ITEM,    "Open Picture...",        "O", 0,    0, (APTR) MITEM_OPEN},
  81.     {NM_ITEM,    NM_BARLABEL,            0, 0, 0, 0},
  82.     {NM_ITEM,    "About MysticView...",    0, 0, 0, (APTR) MITEM_ABOUT},
  83.     {NM_ITEM,    NM_BARLABEL,            0, 0, 0, 0},
  84.     {NM_ITEM,    "Quit",                    "Q", 0, 0, (APTR) MITEM_QUIT},
  85.  
  86.     {NM_TITLE,    "Settings",                0, 0, 0, 0},
  87.     {NM_ITEM,    "Share Screen Pens...",    0, 0, 0, (APTR) MITEM_NOHIGHLIGHT},
  88.     {NM_ITEM,        "Greedy",            0, CHECKIT, 4+8+16, (APTR) MITEM_GREEDY},
  89.     {NM_ITEM,        "Economical",        0, CHECKIT, 2+8+16, (APTR) MITEM_ECONOMICAL},
  90.     {NM_ITEM,        "Sparingly",        0, CHECKIT, 2+4+16, (APTR) MITEM_SPARINGLY},
  91.     {NM_ITEM,        "Passive",            0, CHECKIT, 2+4+8, (APTR) MITEM_PASSIVE},
  92.     {NM_ITEM,    NM_BARLABEL,            0, 0, 0, 0},
  93.     {NM_ITEM,    "HAM Remapping...",        0, 0, 0, (APTR) MITEM_NOHIGHLIGHT},
  94.     {NM_ITEM,        "Fast",                0, CHECKIT, 256+512, (APTR) MITEM_HAM_FAST},
  95.     {NM_ITEM,        "Medium",            0, CHECKIT, 128+512, (APTR) MITEM_HAM_MEDIUM},
  96.     {NM_ITEM,        "Good",                0, CHECKIT, 128+256, (APTR) MITEM_HAM_BEST},
  97.  
  98. /*    {NM_ITEM,    NM_BARLABEL,            0, 0, 0, 0},
  99.     {NM_ITEM,    "Best Refresh for...",    0, 0, 0, (APTR) MITEM_NOHIGHLIGHT},
  100.     {NM_ITEM,        "Slow Graphics",    0, CHECKIT, 8192+16384, 0},
  101.     {NM_ITEM,        "Fast Graphics",    0, CHECKIT, 4096+16384, 0},
  102.     {NM_ITEM,        "Low Memory",        0, CHECKIT, 4096+8192, 0},
  103.     {NM_ITEM,    NM_BARLABEL,            0, 0, 0, 0},
  104.     {NM_ITEM,    "Aspect Ratio...",        0, 0, 0, (APTR) MITEM_NOHIGHLIGHT},
  105.     {NM_ITEM,        "Keep",                0, CHECKIT, 262144+524288, 0},
  106.     {NM_ITEM,        "Ignore Picture",    0, CHECKIT, 131072+524288, 0},
  107.     {NM_ITEM,        "Ignore Screen",    0, CHECKIT, 131072+262144, 0},
  108. */    
  109.     {NM_END, NULL, 0, 0, 0, 0,}
  110. };
  111.  
  112. /*------------------------------------------------------------------*/
  113.  
  114. /*********************************************************************
  115. ----------------------------------------------------------------------
  116.  
  117.     ToggleMenuFlags(menu,identifier,setmask,clearmask)
  118.  
  119. ----------------------------------------------------------------------
  120. *********************************************************************/
  121.  
  122. void ToggleMenuFlags(struct Menu *menu, ULONG id, UWORD set, UWORD clear)
  123. {
  124.     do
  125.     {    
  126.         struct MenuItem *mi = menu->FirstItem;
  127.         do
  128.         {
  129.             if (GTMENUITEM_USERDATA(mi) == (APTR)id)
  130.             {
  131.                 mi->Flags &= ~clear;
  132.                 mi->Flags |= set;
  133.             }
  134.  
  135.         } while (mi = mi->NextItem);
  136.  
  137.     } while (menu = menu->NextMenu);
  138.  
  139. }
  140.  
  141. /*********************************************************************
  142. ----------------------------------------------------------------------
  143.  
  144.     GetMenuFlag(menu,identifier,mask)
  145.  
  146. ----------------------------------------------------------------------
  147. *********************************************************************/
  148.  
  149. ULONG GetMenuFlag(struct Menu *menu, ULONG id)
  150. {
  151.     do
  152.     {    
  153.         struct MenuItem *mi = menu->FirstItem;
  154.         do
  155.         {
  156.             if (GTMENUITEM_USERDATA(mi) == (APTR)id)
  157.             {
  158.                 return ((mi->Flags & CHECKED) ? id : NULL);
  159.             }
  160.  
  161.         } while (mi = mi->NextItem);
  162.  
  163.     } while (menu = menu->NextMenu);
  164.  
  165. }
  166.  
  167. /*********************************************************************
  168. ----------------------------------------------------------------------
  169.  
  170.     GetMenuSettings (wbview)
  171.     get the current settings from the menus.
  172.     
  173. ----------------------------------------------------------------------
  174. *********************************************************************/
  175.  
  176. void GetMenuSettings(struct WBView *wbv)
  177. {
  178.  
  179.     wbv->settings.pensharing =     GetMenuFlag(wbv->menu, MITEM_GREEDY) +
  180.                                 GetMenuFlag(wbv->menu, MITEM_ECONOMICAL) +
  181.                                 GetMenuFlag(wbv->menu, MITEM_SPARINGLY) +
  182.                                 GetMenuFlag(wbv->menu, MITEM_PASSIVE);
  183.  
  184.     wbv->settings.remapping =    GetMenuFlag(wbv->menu, MITEM_HAM_FAST) +
  185.                                 GetMenuFlag(wbv->menu, MITEM_HAM_BEST) +
  186.                                 GetMenuFlag(wbv->menu, MITEM_HAM_MEDIUM);
  187.  
  188. }
  189.  
  190. /*********************************************************************
  191. ----------------------------------------------------------------------
  192.  
  193.     SetMenuSettings (wbview)
  194.     put the current settings into the menus.
  195.     
  196. ----------------------------------------------------------------------
  197. *********************************************************************/
  198.  
  199. void SetMenuSettings(struct WBView *wbv)
  200. {
  201.     #define CLEARITEM(a) ToggleMenuFlags(wbv->menu,a,NULL,CHECKED);
  202.     #define SETITEM(a) ToggleMenuFlags(wbv->menu,a,CHECKED,NULL);
  203.  
  204.  
  205.     ClearMenuStrip(wbv->window);
  206.     
  207.     CLEARITEM(MITEM_GREEDY);
  208.     CLEARITEM(MITEM_ECONOMICAL);
  209.     CLEARITEM(MITEM_SPARINGLY);
  210.     CLEARITEM(MITEM_PASSIVE);
  211.     SETITEM(wbv->settings.pensharing);
  212.  
  213.     CLEARITEM(MITEM_HAM_FAST);
  214.     CLEARITEM(MITEM_HAM_MEDIUM);
  215.     CLEARITEM(MITEM_HAM_BEST);
  216.     SETITEM(wbv->settings.remapping);
  217.  
  218.     ResetMenuStrip(wbv->window, wbv->menu);
  219.  
  220.     #undef    SETITEM
  221.     #undef    CLEARITEM
  222. }
  223.  
  224. /*********************************************************************
  225. ----------------------------------------------------------------------
  226.  
  227.     FileRequest(req, title, pathname, filename)
  228.  
  229. ----------------------------------------------------------------------
  230. *********************************************************************/
  231.  
  232. BOOL FileRequest(struct FileRequester *fr,STRPTR title,STRPTR pathname,STRPTR filename)
  233. {
  234.     BOOL result;
  235.  
  236.     if(result = AslRequestTags(fr,ASLFR_TitleText,title,
  237.             ASLFR_InitialFile,filename,
  238.             ASLFR_InitialDrawer,pathname,
  239.             TAG_DONE))
  240.     {
  241.         if(strlen(fr->fr_File) < FILENAMESIZE)
  242.         {
  243.             if(strlen(fr->fr_Drawer) < PATHNAMESIZE)
  244.             {
  245.                 strcpy(pathname,fr->fr_Drawer);
  246.                 strcpy(filename,fr->fr_File);
  247.             }
  248.             else
  249.             {
  250.                 result = FALSE;
  251.             }
  252.         }
  253.         else
  254.         {
  255.             result = FALSE;
  256.         }
  257.     }
  258.     return result;
  259. }
  260.  
  261.  
  262. /*********************************************************************
  263. ----------------------------------------------------------------------
  264.  
  265.     ProgressFunc()
  266.  
  267.     Progress function to be called when rendering HAM pictures.
  268.  
  269. ----------------------------------------------------------------------
  270. *********************************************************************/
  271.  
  272. ULONG __asm __saveds ProgressFunc(    register __a0 struct Hook *hook,
  273.                                     register __a2 APTR histogram,
  274.                                     register __a1 struct RND_ProgressMessage *message )
  275. {
  276.     static char text[100];
  277.     static WORD oldproz = -1, proz;
  278.     struct WBView *wbv = (struct WBView *) hook->h_Data;
  279.  
  280.     
  281.     proz = (message->RND_PMsg_count * 100 / message->RND_PMsg_total) & ~0x3;
  282.  
  283.     if(proz != oldproz)
  284.     {
  285.         oldproz = proz;
  286.     
  287.         switch(message->RND_PMsg_type)
  288.         {
  289.             case PMSGTYPE_LINES_ADDED:
  290.                 sprintf(text,"Histogram: %d%%",proz);
  291.                 break;
  292.             case PMSGTYPE_COLORS_CHOSEN:
  293.                 sprintf(text,"Palette: %d%%",proz);
  294.                 break;
  295.             case PMSGTYPE_LINES_RENDERED:
  296.                 sprintf(text,"Rendering: %d%%",proz);
  297.                 break;
  298.             case PMSGTYPE_LINES_CONVERTED:
  299.                 sprintf(text,"Converting: %d%%",proz);
  300.                 break;
  301.         }
  302.  
  303.         SetWindowTitles( wbv->window, text, (UBYTE *) ~0 ); 
  304.  
  305.     }            
  306.  
  307.     return TRUE;
  308. }
  309.  
  310.  
  311. /*********************************************************************
  312. ----------------------------------------------------------------------
  313.  
  314.     About(window)
  315.  
  316. ----------------------------------------------------------------------
  317. *********************************************************************/
  318.  
  319. void About(struct Window *win)
  320. {
  321.     static struct EasyStruct req =
  322.     {
  323.         sizeof(struct EasyStruct),0,
  324.  
  325.         "About...",
  326.         PROGNAME "\n"
  327.         "© 1996 by TEK neoscientists.\n\n"
  328.  
  329.         "Written by Captain Bifat,\n"
  330.         "logo drawn by Banshee\n"
  331.         "and Captain Bifat.\n\n"
  332.         
  333.         "MysticView is freeware.\n"
  334.         "It's mainly intended to act as\n"
  335.         "an example for the power of\n"
  336.         "render.library.",
  337.  
  338.         "Okay"
  339.     };
  340.  
  341.     EasyRequest(win,&req,NULL);
  342. }
  343.  
  344.  
  345. /*********************************************************************
  346. ----------------------------------------------------------------------
  347.  
  348.     success = RemapHAM(wbv,chunkyimage, progresshook)
  349.     remap a HAM image to 256 colors.
  350.  
  351. ----------------------------------------------------------------------
  352. *********************************************************************/
  353.  
  354. BOOL RemapHAM(struct WBView *wbv, struct ChunkyImage *ci, struct Hook *progresshook)
  355. {
  356.     ULONG *rgb;    
  357.     BOOL success = FALSE;
  358.  
  359.     ULONG histotype = HSTYPE_15BIT_TURBO;
  360.     ULONG numcolors = 256;
  361.     ULONG interleave = 2;
  362.  
  363.  
  364.     GetMenuSettings(wbv);
  365.     switch (wbv->settings.remapping)
  366.     {
  367.         case MITEM_HAM_FAST:
  368.             histotype = HSTYPE_12BIT_TURBO;
  369.             numcolors = 256;
  370.             interleave = 3;
  371.             break;
  372.  
  373.         case MITEM_HAM_MEDIUM:
  374.             histotype = HSTYPE_15BIT_TURBO;
  375.             numcolors = 256;
  376.             interleave = 2;
  377.             break;
  378.  
  379.         case MITEM_HAM_BEST:
  380.             histotype = HSTYPE_18BIT_TURBO;
  381.             numcolors = 256;
  382.             interleave = 2;
  383.             break;
  384.     }
  385.     
  386.  
  387.  
  388.     /*     
  389.      *    If in HAM mode, the picture has to be re-rendered
  390.      *    completely. This is trivial with render.library.
  391.      *    First, allocate RGB buffer and create a histogram.
  392.      */
  393.  
  394.     if(rgb=AllocVecPooled(ci->width * ci->height * sizeof(ULONG)))
  395.     {
  396.         APTR histo;
  397.             
  398.         if(histo = CreateHistogram(    RND_HSType, histotype, TAG_DONE))
  399.         {
  400.             /*
  401.              *    convert chunky array to RGB,
  402.              *    then add it to the histogram
  403.              */    
  404.  
  405.             Chunky2RGB(ci->chunky, ci->width, ci->height, rgb, ci->palette,
  406.                     RND_ColorMode, ci->colormode,
  407.                     RND_ProgressHook, progresshook,
  408.                     TAG_DONE);                    
  409.  
  410.             /*
  411.              *    we use a trick here:
  412.              *    The histogram is built over every <interleave> raster line.
  413.              */
  414.             
  415.             if(AddRGBImage(histo, rgb, ci->width, ci->height/interleave, 
  416.                     RND_SourceWidth,ci->width*interleave,
  417.                     RND_ProgressHook,progresshook,
  418.                     TAG_DONE) == ADDH_SUCCESS)
  419.             {
  420.                 /*
  421.                  *    Extract palette out of the histogram, then render.
  422.                  */    
  423.  
  424.                 if(ExtractPalette(histo, ci->palette, numcolors,
  425.                             RND_ProgressHook,progresshook,TAG_DONE) == EXTP_SUCCESS)
  426.                 {
  427.                     if (Render(rgb, ci->width, ci->height, ci->chunky, ci->palette, 
  428.                             RND_ProgressHook,progresshook,TAG_DONE) == REND_SUCCESS)
  429.                     {
  430.                         success = TRUE;
  431.                     }
  432.  
  433.                     FlushPalette(ci->palette);
  434.                 }
  435.             }
  436.             DeleteHistogram(histo);
  437.         }
  438.         FreeVecPooled(rgb);
  439.     }
  440.  
  441.     return success;
  442. }
  443.  
  444.  
  445. /*********************************************************************
  446. ----------------------------------------------------------------------
  447.  
  448.     FreeLogo(wbv)
  449.  
  450. ----------------------------------------------------------------------
  451. *********************************************************************/
  452.  
  453. void FreeLogo(struct WBView *wbv)
  454. {
  455.     if(wbv->logopalette)
  456.     {
  457.         DeletePalette(wbv->logopalette);
  458.         wbv->logopalette = NULL;
  459.     }
  460.  
  461.     if(wbv->logopic)
  462.     {
  463.         FreeVecPooled(wbv->logopic);
  464.         wbv->logopic = NULL;
  465.     }
  466. }
  467.  
  468.  
  469. /*********************************************************************
  470. ----------------------------------------------------------------------
  471.  
  472.     BOOL InitLogo(wbv)
  473.  
  474. ----------------------------------------------------------------------
  475. *********************************************************************/
  476.  
  477. BOOL InitLogo(struct WBView *wbv)
  478. {
  479.     if(wbv->logopic == NULL)
  480.     {
  481.         if(!(wbv->logopic = AllocVecPooled(LOGOWIDTH*LOGOHEIGHT)))
  482.         {
  483.             return FALSE;
  484.         }
  485.     }
  486.  
  487.     if(wbv->logopalette == NULL)
  488.     {
  489.         if(!(wbv->logopalette = CreatePalette(RND_HSType,HSTYPE_15BIT,TAG_DONE)))
  490.         {
  491.             return FALSE;
  492.         }
  493.     }
  494.  
  495.     CopyMemQuick(Logo,wbv->logopic,LOGOWIDTH*LOGOHEIGHT);
  496.  
  497.     ImportPalette(wbv->logopalette,LogoPalette,LOGOCOLORS,NULL);
  498.  
  499.     wbv->logo.chunky = wbv->logopic;
  500.     wbv->logo.palette = wbv->logopalette;
  501.     wbv->logo.width = LOGOWIDTH;
  502.     wbv->logo.bytewidth = ((LOGOWIDTH+15)>>4)<<1;
  503.     wbv->logo.height = LOGOHEIGHT;
  504.     wbv->logo.aspect = 1;
  505.     wbv->logo.aspectmode = ASPM_KEEP_ALL;
  506. }
  507.  
  508.  
  509. /*********************************************************************
  510. ----------------------------------------------------------------------
  511.  
  512.     DOUBLE GetScreenAspect(screen)
  513.  
  514. ----------------------------------------------------------------------
  515. *********************************************************************/
  516.  
  517. DOUBLE GetScreenAspect(struct Screen *screen)
  518. {
  519.     ULONG modeID;
  520.  
  521.     if ((modeID = GetVPModeID(&screen->ViewPort)) != INVALID_ID)
  522.     {
  523.         DisplayInfoHandle dih;
  524.  
  525.         if(dih = FindDisplayInfo(modeID))
  526.         {
  527.             struct DisplayInfo di;    
  528.  
  529.             if(GetDisplayInfoData(dih,(UBYTE*)&di, sizeof(struct DisplayInfo),DTAG_DISP,modeID))
  530.             {
  531.                 return (DOUBLE) di.Resolution.x / (DOUBLE) di.Resolution.y;
  532.             }
  533.         }
  534.     }
  535.     return 1;
  536. }
  537.  
  538.  
  539. /*********************************************************************
  540. ----------------------------------------------------------------------
  541.  
  542.     FreeDisplayEntity (displayentity)
  543.  
  544. ----------------------------------------------------------------------
  545. *********************************************************************/
  546.  
  547. void FreeDisplayEntity (struct DisplayEntity *di)
  548.  
  549. {
  550.  
  551.     if(di->psm)
  552.     {
  553.         DeletePenShareMap(di->psm);
  554.         di->psm = NULL;
  555.     }
  556.  
  557.     di->converted = FALSE;
  558.  
  559. }
  560.  
  561.  
  562. /*********************************************************************
  563. ----------------------------------------------------------------------
  564.  
  565.     BOOL Display(wbview)
  566.  
  567. ----------------------------------------------------------------------
  568. *********************************************************************/
  569.  
  570. BOOL Display(struct WBView *wbv)
  571. {
  572.     ULONG winwidth,winheight,width,height,x,y,centerleft,centertop;
  573.     DOUBLE picaspect,winaspect;
  574.     UBYTE *buf;
  575.  
  576.     ULONG bufwidth;
  577.  
  578.     struct DisplayEntity *di = &wbv->disp;
  579.     struct Window *window = wbv->window;
  580.     struct ChunkyImage *ci = di->ci;
  581.  
  582.     
  583.     x = window->BorderLeft;
  584.     y = window->BorderTop;
  585.     winwidth = window->Width - window->BorderRight - x;
  586.     winheight = window->Height - window->BorderBottom - y;
  587.  
  588.     /* 
  589.      *    calculate dimensions
  590.      */
  591.  
  592.     width = winwidth;
  593.  
  594.     if(ci->aspectmode == ASPM_NO_CARE)
  595.     {
  596.         height = winheight;
  597.     }
  598.     else
  599.     {
  600.         picaspect = (ci->aspectmode & ASPM_KEEP_PIC) ? ci->aspect : 1;
  601.         winaspect = (ci->aspectmode & ASPM_KEEP_SCREEN) ? wbv->aspect : 1;
  602.  
  603.         if ( (DOUBLE) winheight > (DOUBLE) width * winaspect )
  604.         {
  605.             height = (DOUBLE) width / (DOUBLE) ci->width * (DOUBLE) ci->height * winaspect / picaspect;
  606.             height = MIN(height,winheight);
  607.             width = (DOUBLE) height / (DOUBLE) ci->height * (DOUBLE) ci->width * picaspect / winaspect; 
  608.         }
  609.         else
  610.         {
  611.             width = (DOUBLE) winheight / (DOUBLE) ci->height * (DOUBLE) ci->width * picaspect / winaspect;
  612.             width = MIN(width,winwidth);
  613.             height = (DOUBLE) width / (DOUBLE) ci->width * (DOUBLE) ci->height * winaspect / picaspect;
  614.         }
  615.     }
  616.  
  617.     bufwidth = (width + 15) & ~0xf;
  618.     centerleft = (winwidth-width)/2;
  619.     centertop = (winheight-height)/2;
  620.  
  621.  
  622.     /*
  623.      *    obtain colors
  624.      */
  625.  
  626.     if(di->psm == NULL)
  627.     {
  628.         if (!(di->psm = CreatePenShareMap()))
  629.         {
  630.             FreeDisplayEntity(di);
  631.             return FALSE;
  632.         }
  633.  
  634.         if (AddChunkyImage(di->psm->histogram,ci->chunky,
  635.                 ci->width,ci->height,ci->palette,NULL) == ADDH_SUCCESS)
  636.         {
  637.             ULONG precision = PRECISION_IMAGE;
  638.  
  639.             RectFill(window->RPort,x,y,x+winwidth-1,y+winheight-1);
  640.  
  641.             GetMenuSettings(wbv);
  642.             switch (wbv->settings.pensharing)
  643.             {
  644.                 case MITEM_GREEDY:
  645.                     precision = PRECISION_EXACT;
  646.                     break;
  647.                 case MITEM_ECONOMICAL:
  648.                     precision = PRECISION_IMAGE;
  649.                     break;
  650.                 case MITEM_SPARINGLY:
  651.                     precision = PRECISION_ICON;
  652.                     break;
  653.                 case MITEM_PASSIVE:
  654.                     precision = PRECISION_GUI;
  655.                     break;
  656.             }
  657.  
  658.             if (!(ObtainPenShareMap(di->psm,window->WScreen->ViewPort.ColorMap,precision)))
  659.             {
  660.                 FreeDisplayEntity(di);
  661.                 return FALSE;
  662.             }
  663.         }
  664.         else
  665.         {
  666.             FreeDisplayEntity(di);
  667.             return FALSE;
  668.         }
  669.     }
  670.  
  671.  
  672.     /*
  673.      *    remap chunky image to screen pens
  674.      */
  675.  
  676.     if(di->converted == FALSE)
  677.     {
  678.         RemapChunkyArray(ci->chunky,ci->palette,
  679.                     ci->width,ci->height,ci->chunky,di->psm);
  680.  
  681.         di->converted = TRUE;
  682.     }
  683.  
  684.  
  685.     /*
  686.      *    scale chunky image to the calculated dimensions,
  687.      *  then dash it into the rastport
  688.      */
  689.  
  690.     if (buf = AllocVecPooled(bufwidth*height))
  691.     {
  692.         APTR scaleengine;
  693.         
  694.         if (scaleengine = CreateScaleEngine(ci->width,ci->height,width,height,NULL))
  695.         {
  696.             Scale(scaleengine,ci->chunky,buf,RND_DestWidth,bufwidth,TAG_DONE);
  697.             DeleteScaleEngine(scaleengine);
  698.  
  699.             DrawChunkyArray(window->RPort,buf,x+centerleft,y+centertop,width,height);
  700.  
  701.             /*
  702.              *    restore the background around the image
  703.              */
  704.  
  705.             if(centertop)
  706.             {
  707.                 RectFill(window->RPort,x,y,x+winwidth-1,y+centertop-1);
  708.                 RectFill(window->RPort,x,y+centertop+height,x+winwidth-1,y+winheight-1);
  709.             }
  710.  
  711.             if(centerleft)
  712.             {
  713.                 RectFill(window->RPort,x,y+centertop,x+centerleft-1,y+centertop+height-1);
  714.                 RectFill(window->RPort,x+centerleft+width,y+centertop,x+winwidth-1,y+centertop+height-1);
  715.             }
  716.  
  717.             FreeVecPooled(buf);
  718.  
  719.             return TRUE;
  720.         }
  721.     }
  722.  
  723.     return FALSE;
  724. }
  725.  
  726.  
  727. /*********************************************************************
  728. ----------------------------------------------------------------------
  729.  
  730.     FreeChunkyImage (chunkyimage)
  731.  
  732. ----------------------------------------------------------------------
  733. *********************************************************************/
  734.  
  735. void FreeChunkyImage(struct ChunkyImage *ci)
  736. {
  737.     if(ci->palette)
  738.     {
  739.         DeletePalette(ci->palette);
  740.         ci->palette = NULL;
  741.     }
  742.  
  743.     if(ci->chunky)
  744.     {
  745.         FreeVecPooled(ci->chunky);
  746.         ci->chunky = NULL;
  747.     }
  748. }
  749.  
  750.  
  751. /*********************************************************************
  752. ----------------------------------------------------------------------
  753.  
  754.     DeleteWBView (wbview)
  755.  
  756. ----------------------------------------------------------------------
  757. *********************************************************************/
  758.  
  759. void DeleteWBView(struct WBView *wbv)
  760. {
  761.  
  762.     if(wbv)
  763.     {
  764.         if(wbv->menu)
  765.         {
  766.             ClearMenuStrip(wbv->window);
  767.         }
  768.     
  769.         if(wbv->freq)
  770.         {
  771.             FreeAslRequest(wbv->freq);
  772.             wbv->freq=NULL;
  773.         }
  774.         
  775.         FreeLogo(wbv);
  776.  
  777.         FreeDisplayEntity(&wbv->disp);
  778.  
  779.         FreeChunkyImage(&wbv->chunkypic);
  780.  
  781.         if(wbv->appwindow)
  782.         {
  783.             RemoveAppWindow(wbv->appwindow);
  784.             wbv->appwindow = NULL;
  785.         }
  786.  
  787.         if(wbv->window)
  788.         {
  789.             CloseWindow(wbv->window);
  790.             wbv->window = NULL;
  791.         }
  792.  
  793.         if(wbv->menu)
  794.         {
  795.             FreeMenus(wbv->menu);
  796.             wbv->menu = NULL;
  797.         }
  798.  
  799.         if(wbv->appmsgport)
  800.         {
  801.             DeleteMsgPort(wbv->appmsgport);
  802.             wbv->appmsgport = NULL;
  803.         }
  804.  
  805.         FreeVecPooled(wbv);
  806.     }
  807.  
  808. }
  809.  
  810.  
  811. /*********************************************************************
  812. ----------------------------------------------------------------------
  813.  
  814.     wbview = CreateWBView (void)
  815.  
  816. ----------------------------------------------------------------------
  817. *********************************************************************/
  818.  
  819. struct WBView *CreateWBView (void)
  820. {
  821.     struct WBView *wbv;
  822.     BOOL success = FALSE;
  823.  
  824.     if (wbv = AllocVecPooled(sizeof(struct WBView)))
  825.     {
  826.         memset(wbv,0,sizeof(struct WBView));
  827.  
  828.         if(wbv->appmsgport = CreateMsgPort())
  829.         {
  830.             if (wbv->pubscreen = LockPubScreen(NULL))
  831.             {
  832.                 wbv->aspect = GetScreenAspect(wbv->pubscreen);
  833.  
  834.                 if (wbv->menu = CreateMenus(mainmenu, TAG_DONE))
  835.                 {
  836.                     ToggleMenuFlags(wbv->menu,MITEM_NOHIGHLIGHT,HIGHNONE,NULL);
  837.  
  838.                     if(wbv->window = OpenWindowTags(NULL, 
  839.                         WA_Width,DEFAULT_WINWIDTH, WA_Height,DEFAULT_WINHEIGHT, 
  840.                         WA_MinWidth,MIN_WINWIDTH, WA_MinHeight,MIN_WINHEIGHT, 
  841.                         WA_MaxWidth,-1, WA_MaxHeight,-1,
  842.                         WA_PubScreen,wbv->pubscreen, WA_Title,PROGNAME,
  843.                         WA_NewLookMenus, TRUE,
  844.                         WA_Flags,WFLG_CLOSEGADGET | WFLG_DRAGBAR | WFLG_SIZEGADGET |
  845.                                 WFLG_DEPTHGADGET | WFLG_SIZEBBOTTOM |
  846.                                 WFLG_SIMPLE_REFRESH,
  847.                         WA_IDCMP,IDCMP_CLOSEWINDOW | IDCMP_NEWSIZE | IDCMP_MENUPICK | IDCMP_REFRESHWINDOW,
  848.                         TAG_DONE))
  849.                     {
  850.                         APTR visinfo;
  851.                         if (visinfo = GetVisualInfo(wbv->pubscreen, TAG_DONE))
  852.                         {
  853.                             if(LayoutMenus(wbv->menu, visinfo, GTMN_NewLookMenus,TRUE,TAG_DONE))
  854.                             {
  855.                                 if(wbv->appwindow = AddAppWindow(ID_APPWIN,UDATA_APPWIN,
  856.                                                         wbv->window,wbv->appmsgport,NULL))
  857.                                 {
  858.                                     if (InitLogo(wbv))
  859.                                     {
  860.  
  861.                                         if(wbv->freq = AllocAslRequestTags(ASL_FileRequest,
  862.                                                 ASLFR_Window,wbv->window,
  863.                                                 ASLFR_SleepWindow,TRUE,
  864.                                                 ASLFR_RejectIcons,TRUE,
  865.                                                 TAG_DONE))
  866.                                         {
  867.                                             success = TRUE;
  868.                                         }
  869.                                     }
  870.                                 }
  871.                             }
  872.                             FreeVisualInfo(visinfo);
  873.                         }
  874.                         
  875.                     }
  876.  
  877.                 }
  878.                 UnlockPubScreen(NULL,wbv->pubscreen);
  879.             }
  880.         }        
  881.     }
  882.  
  883.  
  884.     if(success == TRUE)
  885.     {
  886.         /*
  887.          *    settings
  888.          */
  889.  
  890.         wbv->settings.pensharing = DEFAULT_PENSHARING;
  891.         wbv->settings.remapping = DEFAULT_REMAPPING;
  892.  
  893.         /*
  894.          *    do some more initializations 
  895.          */
  896.  
  897.         SetMenuStrip(wbv->window, wbv->menu);
  898.         SetABPenDrMd(wbv->window->RPort,1,0,JAM2);
  899.  
  900.         SetMenuSettings(wbv);
  901.  
  902.         wbv->ProgressHook.h_Data = wbv;
  903.         wbv->ProgressHook.h_Entry = (ULONG (*)()) ProgressFunc;
  904.  
  905.         wbv->disp.ci = &wbv->logo;
  906.  
  907.         Display(wbv);
  908.     }
  909.     else
  910.     {
  911.         /*
  912.          *    failure - close down gently
  913.          */
  914.  
  915.         DeleteWBView(wbv);
  916.         wbv = NULL;
  917.     }
  918.  
  919.  
  920.     return wbv;
  921. }
  922.  
  923.  
  924. /*********************************************************************
  925. ----------------------------------------------------------------------
  926.  
  927.     BOOL LoadPicture (wbv,chunkyimage,filename,renderhook)
  928.  
  929. ----------------------------------------------------------------------
  930. *********************************************************************/
  931.  
  932. BOOL LoadPicture(struct WBView *wbv, struct ChunkyImage *ci, STRPTR filename, struct Hook *renderhook)
  933. {
  934.     struct Picture pic;
  935.     BOOL success = FALSE;
  936.  
  937.     /*
  938.      *    get DT picture. Remember to use a BMF_STANDARD BitMap,
  939.      *    because we want to convert it via Planar2Chunky()!
  940.      */
  941.  
  942.     if(!GetDataTypesPicture(filename,&pic,BMF_STANDARD))
  943.     {
  944.         ULONG chunkysize = pic.bmap->BytesPerRow * 8 * pic.bmap->Rows;
  945.  
  946.         /*
  947.          *    Allocate buffers for chunky image and palette
  948.          */
  949.  
  950.         if(ci->chunky = AllocVecPooled(chunkysize))
  951.         {
  952.             UWORD histotype = HSTYPE_15BIT_TURBO;
  953.  
  954.             GetMenuSettings(wbv);
  955.             if(wbv->settings.remapping == MITEM_HAM_BEST)
  956.             {
  957.                 histotype = HSTYPE_18BIT_TURBO;
  958.             }
  959.  
  960.             if(ci->palette = CreatePalette(RND_HSType,histotype,TAG_DONE))
  961.             {
  962.                 ULONG ax,ay;
  963.  
  964.                 /*
  965.                  *    fill in parameters
  966.                  */
  967.  
  968.                 ci->width = pic.bmhd.bmh_Width;
  969.                 ci->bytewidth = pic.bmap->BytesPerRow;
  970.                 ci->height = pic.bmap->Rows;
  971.                 ci->displayID = pic.display_ID;
  972.  
  973.                 ax = pic.bmhd.bmh_XAspect;
  974.                 ay = pic.bmhd.bmh_YAspect;
  975.                 ax = !ax ? 1 : ax;
  976.                 ay = !ay ? 1 : ay;
  977.                 ci->aspect = (DOUBLE) ax / (DOUBLE) ay;
  978.                 ci->aspectmode = ASPM_KEEP_ALL;
  979.  
  980.                 if(ci->displayID & HAM)
  981.                 {
  982.                     ci->colormode = (pic.bmap->Depth == 8 ? COLORMODE_HAM8 : COLORMODE_HAM6);
  983.                 }
  984.                 else
  985.                 {    
  986.                     ci->colormode = COLORMODE_CLUT;
  987.                 }
  988.  
  989.                 /*
  990.                  *    convert BitMap's bitplanes to chunky bytes
  991.                  */
  992.  
  993.                 Planar2Chunky(    pic.bmap->Planes,ci->bytewidth,
  994.                                 pic.bmap->Rows,pic.bmap->Depth,
  995.                                 ci->bytewidth,ci->chunky,
  996.                                 RND_DestWidth,ci->width,TAG_DONE    );
  997.  
  998.                 /*
  999.                  *    import image palette
  1000.                  */
  1001.  
  1002.                 ImportPalette(ci->palette, &pic.palette[1], pic.palette_entries,
  1003.                         RND_PaletteFormat, PALFMT_RGB32,
  1004.                         RND_EHBPalette, ((ci->displayID & EXTRA_HALFBRITE) ? TRUE : FALSE),
  1005.                         RND_NewPalette,TRUE,
  1006.                         TAG_DONE);
  1007.  
  1008.                 /*
  1009.                  *    process HAM images
  1010.                  */
  1011.  
  1012.                 if(ci->displayID & HAM)
  1013.                 {
  1014.                     success = RemapHAM(wbv,ci,renderhook);
  1015.                 }
  1016.                 else
  1017.                 {
  1018.                     success = TRUE;                
  1019.                 }
  1020.             }        
  1021.         }
  1022.  
  1023.         if(success == FALSE)
  1024.         {
  1025.             FreeChunkyImage(ci);
  1026.         }
  1027.  
  1028.         /*
  1029.          *    (hopefully) we've got what we want, anyway
  1030.          *    the datatype picture is no longer needed
  1031.          */
  1032.  
  1033.         FreePicture(&pic);
  1034.     }
  1035.  
  1036.     return success;
  1037. }
  1038.  
  1039.  
  1040. /*********************************************************************
  1041. ----------------------------------------------------------------------
  1042.  
  1043.     BOOL ShowPicture(wbview,pathname,filename)
  1044.  
  1045. ----------------------------------------------------------------------
  1046. *********************************************************************/
  1047.  
  1048. BOOL ShowPicture(struct WBView *wbv, STRPTR pathname, STRPTR filename)
  1049. {
  1050.     char formatname[FORMATNAMESIZE];
  1051.     char *infotext;
  1052.     char fullname[FILENAMESIZE+PATHNAMESIZE];
  1053.     BOOL success = FALSE;
  1054.  
  1055.     infotext = "";
  1056.  
  1057.     strcpy(fullname,pathname);
  1058.  
  1059.     if (AddPart(fullname,filename,FILENAMESIZE+PATHNAMESIZE))
  1060.     {
  1061.         if (IsDataTypes(fullname, formatname, FORMATNAMESIZE-1))
  1062.         {
  1063.             FreeChunkyImage(&wbv->chunkypic);
  1064.             FreeDisplayEntity(&wbv->disp);
  1065.  
  1066.             if(LoadPicture(wbv, &wbv->chunkypic,fullname,&wbv->ProgressHook))
  1067.             {
  1068.                 wbv->disp.ci = &wbv->chunkypic;
  1069.                 infotext = INFOTEXT_LOADED;
  1070.                 success = TRUE;
  1071.             }
  1072.             else
  1073.             {
  1074.                 InitLogo(wbv);
  1075.                 wbv->disp.ci = &wbv->logo;
  1076.                 infotext = INFOTEXT_LOAD_ERROR;
  1077.             }
  1078.  
  1079.             Display(wbv);
  1080.         }
  1081.         else
  1082.         {
  1083.             infotext = INFOTEXT_NO_DATATYPE;
  1084.         }
  1085.  
  1086.     }
  1087.  
  1088.     sprintf(wbv->windowtitle,infotext,filename,formatname);
  1089.     SetWindowTitles( wbv->window, wbv->windowtitle, (UBYTE *) ~0 );
  1090.  
  1091.     return success;
  1092. }
  1093.  
  1094.  
  1095. /*********************************************************************
  1096. ----------------------------------------------------------------------
  1097.  
  1098.     HandleWBView (wbview)
  1099.  
  1100. ----------------------------------------------------------------------
  1101. *********************************************************************/
  1102.  
  1103. void HandleWBView(struct WBView *wbv)
  1104. {
  1105.     BOOL finish = FALSE;
  1106.     ULONG idcmpSignal = 1L << wbv->window->UserPort->mp_SigBit;
  1107.     ULONG appSignal = 1L << wbv->appmsgport->mp_SigBit;
  1108.     char pathname[PATHNAMESIZE], filename[FILENAMESIZE];
  1109.  
  1110.     do
  1111.     {
  1112.         struct IntuiMessage *imsg;
  1113.         struct AppMessage *appmsg;
  1114.         BOOL foundpic;
  1115.  
  1116.  
  1117.         Wait(idcmpSignal | appSignal);
  1118.  
  1119.  
  1120.         while (imsg = (struct IntuiMessage *) GetMsg(wbv->window->UserPort))
  1121.         {
  1122.             ULONG iclass = imsg->Class;
  1123.             ULONG icode = imsg->Code;
  1124.  
  1125.             ReplyMsg((struct Message *) imsg);
  1126.             
  1127.             switch (iclass)
  1128.             {
  1129.                 case CLOSEWINDOW:
  1130.                     finish = TRUE;
  1131.                     break;
  1132.                 
  1133.                 case NEWSIZE:
  1134.                     Display(wbv);
  1135.                     RefreshWindowFrame(wbv->window);
  1136.                     break;
  1137.  
  1138.                 case REFRESHWINDOW:
  1139.                     BeginRefresh(wbv->window);
  1140.                     Display(wbv);
  1141.                     EndRefresh(wbv->window,TRUE);
  1142.                     break;
  1143.  
  1144.                 case MENUPICK:
  1145.                     while((icode != MENUNULL) && (finish == FALSE))
  1146.                     {
  1147.                         struct MenuItem *item = ItemAddress(wbv->menu, icode);
  1148.                         ULONG code = (ULONG) MENU_USERDATA(item);
  1149.                         switch (code)
  1150.                         {
  1151.                             case MITEM_OPEN:
  1152.                                 if (FileRequest(wbv->freq, "Load Picture", wbv->pathname, wbv->filename))
  1153.                                 {
  1154.                                     Display(wbv);        /* refresh once again */
  1155.                                     ShowPicture(wbv,wbv->pathname,wbv->filename);
  1156.                                 }
  1157.                                 break;
  1158.  
  1159.                             case MITEM_ABOUT:
  1160.                                 About(wbv->window);
  1161.                                 break;
  1162.  
  1163.                             case MITEM_QUIT:
  1164.                                 finish = TRUE;
  1165.                                 break;
  1166.                         }
  1167.                         icode = item->NextSelect;
  1168.  
  1169.                     }
  1170.                     break;
  1171.             }
  1172.  
  1173.         }
  1174.  
  1175.  
  1176.         foundpic = FALSE;
  1177.         while (appmsg = (struct AppMessage *) GetMsg(wbv->appmsgport))
  1178.         {
  1179.             int i;
  1180.             struct WBArg *argptr = appmsg->am_ArgList;
  1181.  
  1182.             for (i = 0; i < appmsg->am_NumArgs && foundpic == FALSE; i++)
  1183.             {
  1184.                 if (NameFromLock(argptr->wa_Lock,pathname,PATHNAMESIZE))
  1185.                 {
  1186.                     if(strlen(argptr->wa_Name))
  1187.                     {
  1188.                         strcpy(filename,argptr->wa_Name);
  1189.                         foundpic = TRUE;
  1190.                     }
  1191.                 }
  1192.                 argptr++;        /* point to next argument */
  1193.             }
  1194.             ReplyMsg((struct Message *) appmsg);
  1195.         }
  1196.  
  1197.         if(foundpic == TRUE)
  1198.         {
  1199.             /*
  1200.              *    we've found something. Maybe it's a
  1201.              *    valid datatype picture class file?
  1202.              *    We find out by trying.
  1203.              */
  1204.  
  1205.             strcpy(wbv->pathname,pathname);
  1206.             strcpy(wbv->filename,filename);
  1207.             ShowPicture(wbv,pathname,filename);
  1208.         }
  1209.  
  1210.     } while (finish == FALSE);
  1211.  
  1212. }
  1213.  
  1214.  
  1215. /*********************************************************************
  1216. ----------------------------------------------------------------------
  1217.  
  1218.     main
  1219.  
  1220. ----------------------------------------------------------------------
  1221. *********************************************************************/
  1222.  
  1223. void main (void)
  1224. {
  1225.  
  1226.     if(InitGlobal())
  1227.     {
  1228.         struct WBView *viewer;
  1229.  
  1230.         if (viewer = CreateWBView())
  1231.         {
  1232.             HandleWBView(viewer);
  1233.             DeleteWBView(viewer);
  1234.         }
  1235.     
  1236.         CloseGlobal();
  1237.     }
  1238. }
  1239.